home *** CD-ROM | disk | FTP | other *** search
/ CD Classic 39 / CD CLASSIC #39 (1998).iso / EMPRESA / visio / Vistdstd / Install / Data.Z / NT40wrap.H < prev    next >
C/C++ Source or Header  |  1996-10-18  |  17KB  |  610 lines
  1. /* NT40WRAP.H - Workaround for 'too many shape methods' problem
  2.  * Copyright (C) 1996 Visio Corporation. All rights reserved.
  3.  */
  4.  
  5. //    On Windows NT 4.0, if you build an executable controller,
  6. //    calling the 105th custom interface method (or higher than
  7. //    105th) through the dual interface causes NT to puke in RPC
  8. //    code. Therefore, we provide this file which allows methods
  9. //    105 and higher for our IVShape interface (DropMany and beyond)
  10. //    to be called via IDispatch::Invoke. Fortunately for us, the
  11. //    IVShape interface is the only Visio interface large enough to
  12. //    have to workaround...
  13. //
  14. //    If you're building a controller as an EXE which will be run
  15. //    on NT 4.0, then include this file after including VISIWRAP.H
  16. //    in your source files.
  17. //
  18. //    This workaround is equivalent to 'Dim a as Object' in VB.
  19.  
  20. #ifndef _NT40WRAP_H
  21. #define _NT40WRAP_H
  22.  
  23. #ifndef _Visiwrap_H
  24. #include "visiwrap.h"
  25. #endif
  26.  
  27. /******************************************************************************/
  28. //  Declaration of class CVisioShape_NT40
  29.  
  30. class FAR CVisioShape_NT40 : public CVisioShape
  31. {
  32. VW_PUBLIC:
  33.     CVisioShape_NT40()
  34.         : CVisioShape() { m_pDispatch= NULL; }
  35.  
  36.     CVisioShape_NT40(const CVisioShape_NT40& other)
  37.         : CVisioShape(other) { m_pDispatch= NULL; }
  38.  
  39.     CVisioShape_NT40(const ::IVShape FAR * other)
  40.         : CVisioShape(other) { m_pDispatch= NULL; }
  41.  
  42.     const CVisioShape_NT40 FAR & operator=(const CVisioShape_NT40 FAR &other)
  43.         {
  44.         if ( &other != this )
  45.             {
  46.             ReleaseDispatch();
  47.             CopyIP(other.GetUnknown());
  48.             }
  49.  
  50.         return *this;
  51.         }
  52.  
  53.     const CVisioShape_NT40 FAR & operator=(const ::IVShape FAR * other)
  54.         {
  55.         if ( (LPUNKNOWN)other != GetUnknown() )
  56.             {
  57.             ReleaseDispatch();
  58.             CopyIP( (LPUNKNOWN)other );
  59.             }
  60.  
  61.         return *this;
  62.         }
  63.  
  64.     virtual ~CVisioShape_NT40() { ReleaseDispatch(); }
  65.  
  66.     ::IVShape FAR * GetIP() const { return (::IVShape FAR *) GetUnknown(); }
  67.  
  68.     operator ::IVShape FAR * () { return (::IVShape FAR *) GetUnknown(); }
  69.  
  70. VW_PUBLIC:
  71.     HRESULT DropMany(/*VARIANT*/ SAFEARRAY FAR * FAR *ObjectsToInstance, /*double*/ SAFEARRAY FAR * FAR *xyArray, /*short*/ SAFEARRAY FAR * FAR *IDArray, short FAR *lpRet);
  72.     HRESULT GetFormulas(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *formulaArray);
  73.     HRESULT GetResults(/*short*/ SAFEARRAY FAR * FAR *SRCStream, short Flags, /*VARIANT*/ SAFEARRAY FAR * FAR *UnitsNamesOrCodes, /*VARIANT*/ SAFEARRAY FAR * FAR *resultArray);
  74.     HRESULT SetFormulas(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *formulaArray, short Flags, short FAR *lpRet);
  75.     HRESULT SetResults(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *UnitsNamesOrCodes, /*VARIANT*/ SAFEARRAY FAR * FAR *resultArray, short Flags, short FAR *lpRet);
  76.     HRESULT FromConnects(CVisioConnects FAR &rWrap);
  77.     HRESULT Layout();
  78.     HRESULT BoundingBox(short Flags, double FAR *lpr8Left, double FAR *lpr8Bottom, double FAR *lpr8Right, double FAR *lpr8Top);
  79.  
  80. private:
  81.     IDispatch FAR *GetDispatch(void);
  82.     void ReleaseDispatch(void);
  83.  
  84.     IDispatch FAR *m_pDispatch;
  85. };
  86.  
  87.  
  88. VW_INLINE IDispatch FAR *CVisioShape_NT40::GetDispatch(void)
  89. {
  90.     HRESULT hr= NOERROR;
  91.  
  92.     if (NULL==m_pDispatch && NULL!=GetIP())
  93.     {
  94.         hr= GetIP()->QueryInterface(IID_IDispatch, (LPVOID FAR *) &m_pDispatch);
  95.     }
  96.  
  97.     return m_pDispatch;
  98. }
  99.  
  100.  
  101. VW_INLINE void CVisioShape_NT40::ReleaseDispatch(void)
  102. {
  103.     if (NULL!=m_pDispatch)
  104.     {
  105.         m_pDispatch->Release();
  106.         m_pDispatch= NULL;
  107.     }
  108. }
  109.  
  110.  
  111. #define DISPID_DropMany            92
  112. #define DISPID_GetFormulas        93
  113. #define DISPID_GetResults        94
  114. #define DISPID_SetFormulas        95
  115. #define DISPID_SetResults        96
  116. #define DISPID_FromConnects        97
  117. #define DISPID_Layout            98
  118. #define DISPID_BoundingBox        99
  119.  
  120.  
  121. VW_INLINE HRESULT CVisioShape_NT40::DropMany(/*VARIANT*/ SAFEARRAY FAR * FAR *ObjectsToInstance, /*double*/ SAFEARRAY FAR * FAR *xyArray, /*short*/ SAFEARRAY FAR * FAR *IDArray, short FAR *lpRet)
  122. {
  123.     HRESULT hr= E_FAIL;
  124.     IDispatch FAR *pDispatch= GetDispatch();
  125.  
  126.     CHECK_IP(GetIP(), CVisioShape_NT40, DropMany);
  127.  
  128.     if (NULL!=pDispatch)
  129.     {
  130.         unsigned short wFlags= DISPATCH_METHOD;
  131.         DISPPARAMS dispParams;
  132.         VARIANT vaResult;
  133.         EXCEPINFO excepInfo;
  134.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  135.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  136.         VARIANTARG vArgs[3];
  137.  
  138.  
  139.         //    Initialize all the inputs:
  140.         memset(&dispParams, 0, sizeof dispParams);
  141.         dispParams.rgvarg= vArgs;
  142.             VariantInit(&vArgs[2]);
  143.             V_VT(&vArgs[2])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  144.             V_ARRAYREF(&vArgs[2])= ObjectsToInstance;
  145.  
  146.             VariantInit(&vArgs[1]);
  147.             V_VT(&vArgs[1])= VT_ARRAY | VT_BYREF | VT_R8;
  148.             V_ARRAYREF(&vArgs[1])= xyArray;
  149.  
  150.             VariantInit(&vArgs[0]);
  151.             V_VT(&vArgs[0])= VT_ARRAY | VT_BYREF | VT_I2;
  152.             V_ARRAYREF(&vArgs[0])= IDArray;
  153.         dispParams.cArgs= 3;
  154.  
  155.         VariantInit(&vaResult);
  156.  
  157.         memset(&excepInfo, 0, sizeof excepInfo);
  158.  
  159.         //    Make the call:
  160.         hr= pDispatch->Invoke(DISPID_DropMany, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  161.  
  162.  
  163.         //    Because DropMany is declared as having a 'retval' in the TypeLib,
  164.         //    we have to look to vaResult for the return value...
  165.         if (NOERROR==hr)
  166.         {
  167.             if (VT_I2!=V_VT(&vaResult))
  168.                 hr= VariantChangeType(&vaResult, &vaResult, 0, VT_I2);
  169.  
  170.             if (NOERROR==hr)
  171.             {
  172.                 if (NULL==lpRet)
  173.                     hr= E_POINTER;
  174.                 else
  175.                     (*lpRet)= (short) V_I2(&vaResult);
  176.             }
  177.         }
  178.  
  179.         VariantClear(&vaResult);
  180.         VariantClear(&vArgs[0]);
  181.         VariantClear(&vArgs[1]);
  182.         VariantClear(&vArgs[2]);
  183.     }
  184.  
  185.     CHECK_HRESULT(hr, CVisioShape_NT40, DropMany);
  186.  
  187.     return hr;
  188. }
  189.  
  190.  
  191. VW_INLINE HRESULT CVisioShape_NT40::GetFormulas(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *formulaArray)
  192. {
  193.     HRESULT hr= E_FAIL;
  194.     IDispatch FAR *pDispatch= GetDispatch();
  195.  
  196.     CHECK_IP(GetIP(), CVisioShape_NT40, GetFormulas);
  197.  
  198.     if (NULL!=pDispatch)
  199.     {
  200.         unsigned short wFlags= DISPATCH_METHOD;
  201.         DISPPARAMS dispParams;
  202.         VARIANT vaResult;
  203.         EXCEPINFO excepInfo;
  204.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  205.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  206.         VARIANTARG vArgs[2];
  207.  
  208.  
  209.         //    Initialize all the inputs:
  210.         memset(&dispParams, 0, sizeof dispParams);
  211.         dispParams.rgvarg= vArgs;
  212.             VariantInit(&vArgs[1]);
  213.             V_VT(&vArgs[1])= VT_ARRAY | VT_BYREF | VT_I2;
  214.             V_ARRAYREF(&vArgs[1])= SRCStream;
  215.  
  216.             VariantInit(&vArgs[0]);
  217.             V_VT(&vArgs[0])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  218.             V_ARRAYREF(&vArgs[0])= formulaArray;
  219.         dispParams.cArgs= 2;
  220.  
  221.         VariantInit(&vaResult);
  222.  
  223.         memset(&excepInfo, 0, sizeof excepInfo);
  224.  
  225.         //    Make the call:
  226.         hr= pDispatch->Invoke(DISPID_GetFormulas, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  227.  
  228.         VariantClear(&vaResult);
  229.         VariantClear(&vArgs[0]);
  230.         VariantClear(&vArgs[1]);
  231.     }
  232.  
  233.     CHECK_HRESULT(hr, CVisioShape_NT40, GetFormulas);
  234.  
  235.     return hr;
  236. }
  237.  
  238.  
  239. VW_INLINE HRESULT CVisioShape_NT40::GetResults(/*short*/ SAFEARRAY FAR * FAR *SRCStream, short Flags, /*VARIANT*/ SAFEARRAY FAR * FAR *UnitsNamesOrCodes, /*VARIANT*/ SAFEARRAY FAR * FAR *resultArray)
  240. {
  241.     HRESULT hr= E_FAIL;
  242.     IDispatch FAR *pDispatch= GetDispatch();
  243.  
  244.     CHECK_IP(GetIP(), CVisioShape_NT40, GetResults);
  245.  
  246.     if (NULL!=pDispatch)
  247.     {
  248.         unsigned short wFlags= DISPATCH_METHOD;
  249.         DISPPARAMS dispParams;
  250.         VARIANT vaResult;
  251.         EXCEPINFO excepInfo;
  252.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  253.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  254.         VARIANTARG vArgs[4];
  255.  
  256.  
  257.         //    Initialize all the inputs:
  258.         memset(&dispParams, 0, sizeof dispParams);
  259.         dispParams.rgvarg= vArgs;
  260.             VariantInit(&vArgs[3]);
  261.             V_VT(&vArgs[3])= VT_ARRAY | VT_BYREF | VT_I2;
  262.             V_ARRAYREF(&vArgs[3])= SRCStream;
  263.  
  264.             VariantInit(&vArgs[2]);
  265.             V_VT(&vArgs[2])= VT_I2;
  266.             V_I2(&vArgs[2])= Flags;
  267.  
  268.             VariantInit(&vArgs[1]);
  269.             V_VT(&vArgs[1])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  270.             V_ARRAYREF(&vArgs[1])= UnitsNamesOrCodes;
  271.  
  272.             VariantInit(&vArgs[0]);
  273.             V_VT(&vArgs[0])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  274.             V_ARRAYREF(&vArgs[0])= resultArray;
  275.         dispParams.cArgs= 4;
  276.  
  277.         VariantInit(&vaResult);
  278.  
  279.         memset(&excepInfo, 0, sizeof excepInfo);
  280.  
  281.         //    Make the call:
  282.         hr= pDispatch->Invoke(DISPID_GetResults, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  283.  
  284.         VariantClear(&vaResult);
  285.         VariantClear(&vArgs[0]);
  286.         VariantClear(&vArgs[1]);
  287.         VariantClear(&vArgs[2]);
  288.         VariantClear(&vArgs[3]);
  289.     }
  290.  
  291.     CHECK_HRESULT(hr, CVisioShape_NT40, GetResults);
  292.  
  293.     return hr;
  294. }
  295.  
  296.  
  297. VW_INLINE HRESULT CVisioShape_NT40::SetFormulas(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *formulaArray, short Flags, short FAR *lpRet)
  298. {
  299.     HRESULT hr= E_FAIL;
  300.     IDispatch FAR *pDispatch= GetDispatch();
  301.  
  302.     CHECK_IP(GetIP(), CVisioShape_NT40, SetFormulas);
  303.  
  304.     if (NULL!=pDispatch)
  305.     {
  306.         unsigned short wFlags= DISPATCH_METHOD;
  307.         DISPPARAMS dispParams;
  308.         VARIANT vaResult;
  309.         EXCEPINFO excepInfo;
  310.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  311.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  312.         VARIANTARG vArgs[3];
  313.  
  314.  
  315.         //    Initialize all the inputs:
  316.         memset(&dispParams, 0, sizeof dispParams);
  317.         dispParams.rgvarg= vArgs;
  318.             VariantInit(&vArgs[2]);
  319.             V_VT(&vArgs[2])= VT_ARRAY | VT_BYREF | VT_I2;
  320.             V_ARRAYREF(&vArgs[2])= SRCStream;
  321.  
  322.             VariantInit(&vArgs[1]);
  323.             V_VT(&vArgs[1])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  324.             V_ARRAYREF(&vArgs[1])= formulaArray;
  325.  
  326.             VariantInit(&vArgs[0]);
  327.             V_VT(&vArgs[0])= VT_I2;
  328.             V_I2(&vArgs[0])= Flags;
  329.         dispParams.cArgs= 3;
  330.  
  331.         VariantInit(&vaResult);
  332.  
  333.         memset(&excepInfo, 0, sizeof excepInfo);
  334.  
  335.         //    Make the call:
  336.         hr= pDispatch->Invoke(DISPID_SetFormulas, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  337.  
  338.  
  339.         //    Because SetFormulas is declared as having a 'retval' in the TypeLib,
  340.         //    we have to look to vaResult for the return value...
  341.         if (NOERROR==hr)
  342.         {
  343.             if (VT_I2!=V_VT(&vaResult))
  344.                 hr= VariantChangeType(&vaResult, &vaResult, 0, VT_I2);
  345.  
  346.             if (NOERROR==hr)
  347.             {
  348.                 if (NULL==lpRet)
  349.                     hr= E_POINTER;
  350.                 else
  351.                     (*lpRet)= (short) V_I2(&vaResult);
  352.             }
  353.         }
  354.  
  355.         VariantClear(&vaResult);
  356.         VariantClear(&vArgs[0]);
  357.         VariantClear(&vArgs[1]);
  358.         VariantClear(&vArgs[2]);
  359.     }
  360.  
  361.     CHECK_HRESULT(hr, CVisioShape_NT40, SetFormulas);
  362.  
  363.     return hr;
  364. }
  365.  
  366.  
  367. VW_INLINE HRESULT CVisioShape_NT40::SetResults(/*short*/ SAFEARRAY FAR * FAR *SRCStream, /*VARIANT*/ SAFEARRAY FAR * FAR *UnitsNamesOrCodes, /*VARIANT*/ SAFEARRAY FAR * FAR *resultArray, short Flags, short FAR *lpRet)
  368. {
  369.     HRESULT hr= E_FAIL;
  370.     IDispatch FAR *pDispatch= GetDispatch();
  371.  
  372.     CHECK_IP(GetIP(), CVisioShape_NT40, SetResults);
  373.  
  374.     if (NULL!=pDispatch)
  375.     {
  376.         unsigned short wFlags= DISPATCH_METHOD;
  377.         DISPPARAMS dispParams;
  378.         VARIANT vaResult;
  379.         EXCEPINFO excepInfo;
  380.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  381.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  382.         VARIANTARG vArgs[4];
  383.  
  384.  
  385.         //    Initialize all the inputs:
  386.         memset(&dispParams, 0, sizeof dispParams);
  387.         dispParams.rgvarg= vArgs;
  388.             VariantInit(&vArgs[3]);
  389.             V_VT(&vArgs[3])= VT_ARRAY | VT_BYREF | VT_I2;
  390.             V_ARRAYREF(&vArgs[3])= SRCStream;
  391.  
  392.             VariantInit(&vArgs[2]);
  393.             V_VT(&vArgs[2])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  394.             V_ARRAYREF(&vArgs[2])= UnitsNamesOrCodes;
  395.  
  396.             VariantInit(&vArgs[1]);
  397.             V_VT(&vArgs[1])= VT_ARRAY | VT_BYREF | VT_VARIANT;
  398.             V_ARRAYREF(&vArgs[1])= resultArray;
  399.  
  400.             VariantInit(&vArgs[0]);
  401.             V_VT(&vArgs[0])= VT_I2;
  402.             V_I2(&vArgs[0])= Flags;
  403.         dispParams.cArgs= 4;
  404.  
  405.         VariantInit(&vaResult);
  406.  
  407.         memset(&excepInfo, 0, sizeof excepInfo);
  408.  
  409.         //    Make the call:
  410.         hr= pDispatch->Invoke(DISPID_SetResults, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  411.  
  412.  
  413.         //    Because SetResults is declared as having a 'retval' in the TypeLib,
  414.         //    we have to look to vaResult for the return value...
  415.         if (NOERROR==hr)
  416.         {
  417.             if (VT_I2!=V_VT(&vaResult))
  418.                 hr= VariantChangeType(&vaResult, &vaResult, 0, VT_I2);
  419.  
  420.             if (NOERROR==hr)
  421.             {
  422.                 if (NULL==lpRet)
  423.                     hr= E_POINTER;
  424.                 else
  425.                     (*lpRet)= (short) V_I2(&vaResult);
  426.             }
  427.         }
  428.  
  429.         VariantClear(&vaResult);
  430.         VariantClear(&vArgs[0]);
  431.         VariantClear(&vArgs[1]);
  432.         VariantClear(&vArgs[2]);
  433.         VariantClear(&vArgs[3]);
  434.     }
  435.  
  436.     CHECK_HRESULT(hr, CVisioShape_NT40, SetResults);
  437.  
  438.     return hr;
  439. }
  440.  
  441.  
  442. VW_INLINE HRESULT CVisioShape_NT40::FromConnects(CVisioConnects FAR &rWrap)
  443. {
  444.     HRESULT hr= E_FAIL;
  445.     IDispatch FAR *pDispatch= GetDispatch();
  446.     IVConnects FAR *pConnects= NULL;
  447.  
  448.     CHECK_IP(GetIP(), CVisioShape_NT40, FromConnects);
  449.  
  450.     if (NULL!=pDispatch)
  451.     {
  452.         //    This one is a 'propget'
  453.         unsigned short wFlags= DISPATCH_METHOD | DISPATCH_PROPERTYGET;
  454.         DISPPARAMS dispParams;
  455.         VARIANT vaResult;
  456.         EXCEPINFO excepInfo;
  457.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  458.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  459.  
  460.  
  461.         //    Initialize all the inputs:
  462.         memset(&dispParams, 0, sizeof dispParams);
  463.         dispParams.rgvarg= NULL;
  464.         dispParams.cArgs= 0;
  465.  
  466.         VariantInit(&vaResult);
  467.  
  468.         memset(&excepInfo, 0, sizeof excepInfo);
  469.  
  470.         //    Make the call:
  471.         hr= pDispatch->Invoke(DISPID_FromConnects, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  472.  
  473.  
  474.         //    Because FromConnects is declared as having a 'retval' in the TypeLib,
  475.         //    we have to look to vaResult for the return value...
  476.         if (NOERROR==hr)
  477.         {
  478.             if (VT_DISPATCH!=V_VT(&vaResult))
  479.                 hr= VariantChangeType(&vaResult, &vaResult, 0, VT_DISPATCH);
  480.  
  481.             if (NOERROR==hr && NULL!=V_DISPATCH(&vaResult))
  482.                 hr= V_DISPATCH(&vaResult)->QueryInterface(IID_IVConnects, (LPVOID FAR *) &pConnects);
  483.         }
  484.  
  485.         VariantClear(&vaResult);
  486.     }
  487.  
  488.     rWrap= pConnects;
  489.  
  490.     if (NULL!=pConnects)
  491.         pConnects->Release();
  492.  
  493.     CHECK_HRESULT(hr, CVisioShape_NT40, FromConnects);
  494.  
  495.     return hr;
  496. }
  497.  
  498.  
  499. VW_INLINE HRESULT CVisioShape_NT40::Layout()
  500. {
  501.     HRESULT hr= E_FAIL;
  502.     IDispatch FAR *pDispatch= GetDispatch();
  503.  
  504.     CHECK_IP(GetIP(), CVisioShape_NT40, Layout);
  505.  
  506.     if (NULL!=pDispatch)
  507.     {
  508.         unsigned short wFlags= DISPATCH_METHOD;
  509.         DISPPARAMS dispParams;
  510.         VARIANT vaResult;
  511.         EXCEPINFO excepInfo;
  512.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  513.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  514.  
  515.  
  516.         //    Initialize all the inputs:
  517.         memset(&dispParams, 0, sizeof dispParams);
  518.         dispParams.rgvarg= NULL;
  519.         dispParams.cArgs= 0;
  520.  
  521.         VariantInit(&vaResult);
  522.  
  523.         memset(&excepInfo, 0, sizeof excepInfo);
  524.  
  525.         //    Make the call:
  526.         hr= pDispatch->Invoke(DISPID_Layout, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  527.  
  528.         VariantClear(&vaResult);
  529.     }
  530.  
  531.     CHECK_HRESULT(hr, CVisioShape_NT40, Layout);
  532.  
  533.     return hr;
  534. }
  535.  
  536.  
  537. VW_INLINE HRESULT CVisioShape_NT40::BoundingBox(short Flags, double FAR *lpr8Left, double FAR *lpr8Bottom, double FAR *lpr8Right, double FAR *lpr8Top)
  538. {
  539.     HRESULT hr= E_FAIL;
  540.     IDispatch FAR *pDispatch= GetDispatch();
  541.  
  542.     CHECK_IP(GetIP(), CVisioShape_NT40, BoundingBox);
  543.  
  544.     if (NULL!=pDispatch)
  545.     {
  546.         unsigned short wFlags= DISPATCH_METHOD;
  547.         DISPPARAMS dispParams;
  548.         VARIANT vaResult;
  549.         EXCEPINFO excepInfo;
  550.         UINT nArgErr= (UINT) -1;    // initialize to invalid arg
  551.         IID iidNULL= { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
  552.         VARIANTARG vArgs[5];
  553.  
  554.  
  555.         //    Initialize all the inputs:
  556.         memset(&dispParams, 0, sizeof dispParams);
  557.         dispParams.rgvarg= vArgs;
  558.             VariantInit(&vArgs[4]);
  559.             V_VT(&vArgs[4])= VT_I2;
  560.             V_I2(&vArgs[4])= Flags;
  561.  
  562.             VariantInit(&vArgs[3]);
  563.             V_VT(&vArgs[3])= VT_BYREF | VT_R8;
  564.             V_R8REF(&vArgs[3])= lpr8Left;
  565.  
  566.             VariantInit(&vArgs[2]);
  567.             V_VT(&vArgs[2])= VT_BYREF | VT_R8;
  568.             V_R8REF(&vArgs[2])= lpr8Bottom;
  569.  
  570.             VariantInit(&vArgs[1]);
  571.             V_VT(&vArgs[1])= VT_BYREF | VT_R8;
  572.             V_R8REF(&vArgs[1])= lpr8Right;
  573.  
  574.             VariantInit(&vArgs[0]);
  575.             V_VT(&vArgs[0])= VT_BYREF | VT_R8;
  576.             V_R8REF(&vArgs[0])= lpr8Top;
  577.         dispParams.cArgs= 5;
  578.  
  579.         VariantInit(&vaResult);
  580.  
  581.         memset(&excepInfo, 0, sizeof excepInfo);
  582.  
  583.         //    Make the call:
  584.         hr= pDispatch->Invoke(DISPID_BoundingBox, iidNULL, 0, wFlags, &dispParams, &vaResult, &excepInfo, &nArgErr);
  585.  
  586.         VariantClear(&vaResult);
  587.         VariantClear(&vArgs[0]);
  588.         VariantClear(&vArgs[1]);
  589.         VariantClear(&vArgs[2]);
  590.         VariantClear(&vArgs[3]);
  591.         VariantClear(&vArgs[4]);
  592.     }
  593.  
  594.     CHECK_HRESULT(hr, CVisioShape_NT40, BoundingBox);
  595.  
  596.     return hr;
  597. }
  598.  
  599. //    Make its use 'transparent':
  600. #undef CVisioShape
  601. #define CVisioShape CVisioShape_NT40
  602.  
  603. //    That is, people who need to accomodate NT 4.0 Executable
  604. //    controllers will include this file, but continue using
  605. //    'CVisioShape' in their code. The above #define forces
  606. //    them to use CVisioShape_NT40 instead without them even
  607. //    having to know it... Wild, huh?
  608.  
  609. #endif    //    _NT40WRAP_H
  610.